/**
 * 场景树加载器
 * 将完整的树形数据拆分为：
 * 1. 树关系（只有ID和父子关系）
 * 2. 节点配置数组（平面结构）
 */
class SceneTreeLoader {
    constructor() {
        this.treeStructure = null;  // 树关系
        this.nodesArray = [];       // 节点配置数组
        this.nodesMap = new Map();  // 节点ID映射表
    }

    /**
     * 从完整的树形JSON加载并分离数据
     * @param {Object} fullTreeData - 完整的树形数据
     */
    loadFromFullTree(fullTreeData) {
        console.log('   → 解析场景树数据...');
        
        // 清空之前的数据
        this.nodesArray = [];
        this.nodesMap.clear();
        
        // 递归提取节点配置到平面数组
        this.extractNodesRecursive(fullTreeData.root);
        
        // 生成简化的树结构（只保留ID和父子关系）
        this.treeStructure = this.buildTreeStructure(fullTreeData.root);
        
        console.log('   ✓ 场景树数据解析完成');
        console.log('     - 树节点数:', this.nodesArray.length);
        console.log('     - 树深度:', this.calculateTreeDepth(this.treeStructure));
        
        return {
            tree: this.treeStructure,
            nodes: this.nodesArray
        };
    }

    /**
     * 递归提取节点配置到平面数组
     */
    extractNodesRecursive(node) {
        if (!node) return;
        
        // ✅ 提取节点配置（不包含children），保留transform等其他属性
        const nodeConfig = {
            id: node.id,
            name: node.name,
            type: node.type,
            visible: node.visible !== undefined ? node.visible : true,
            locked: node.locked !== undefined ? node.locked : false,
            userData: node.userData || {}
        };
        
        // ✅ 保留其他属性（如 transform、components 等），但排除 position/rotation/scale/modelPath
        Object.keys(node).forEach(key => {
            if (!['id', 'name', 'type', 'visible', 'locked', 'userData', 'children', 'position', 'rotation', 'scale', 'modelPath'].includes(key)) {
                nodeConfig[key] = node[key];
            }
        });
        
        // 添加到数组和映射表
        this.nodesArray.push(nodeConfig);
        this.nodesMap.set(node.id, nodeConfig);
        
        // 递归处理子节点
        if (node.children && node.children.length > 0) {
            node.children.forEach(child => this.extractNodesRecursive(child));
        }
    }

    /**
     * 构建简化的树结构（只保留ID和父子关系）
     */
    buildTreeStructure(node) {
        if (!node) return null;
        
        const structure = {
            id: node.id,
            children: []
        };
        
        // 递归构建子节点结构
        if (node.children && node.children.length > 0) {
            structure.children = node.children.map(child => 
                this.buildTreeStructure(child)
            ).filter(child => child !== null);
        }
        
        return structure;
    }

    /**
     * 计算树深度
     */
    calculateTreeDepth(node, currentDepth = 0) {
        if (!node || !node.children || node.children.length === 0) {
            return currentDepth;
        }
        
        let maxDepth = currentDepth;
        for (const child of node.children) {
            const childDepth = this.calculateTreeDepth(child, currentDepth + 1);
            maxDepth = Math.max(maxDepth, childDepth);
        }
        
        return maxDepth;
    }

    /**
     * 根据ID获取节点配置
     */
    getNodeById(nodeId) {
        return this.nodesMap.get(nodeId);
    }

    /**
     * 获取节点的所有子节点ID（递归）
     */
    getChildNodeIds(nodeId, structure = this.treeStructure) {
        if (!structure) return [];
        
        if (structure.id === nodeId) {
            return this.collectAllChildIds(structure);
        }
        
        // 递归查找
        for (const child of structure.children) {
            const result = this.getChildNodeIds(nodeId, child);
            if (result.length > 0) {
                return result;
            }
        }
        
        return [];
    }

    /**
     * 收集所有子节点ID
     */
    collectAllChildIds(structure) {
        const ids = [];
        
        if (structure.children && structure.children.length > 0) {
            for (const child of structure.children) {
                ids.push(child.id);
                ids.push(...this.collectAllChildIds(child));
            }
        }
        
        return ids;
    }

    /**
     * 查找节点在树中的路径（从根到该节点的ID数组）
     */
    findNodePath(nodeId, structure = this.treeStructure, currentPath = []) {
        if (!structure) return null;
        
        const newPath = [...currentPath, structure.id];
        
        if (structure.id === nodeId) {
            return newPath;
        }
        
        // 递归查找子节点
        for (const child of structure.children) {
            const result = this.findNodePath(nodeId, child, newPath);
            if (result) {
                return result;
            }
        }
        
        return null;
    }

    /**
     * 获取所有节点配置
     */
    getAllNodes() {
        return this.nodesArray;
    }

    /**
     * 获取树结构
     */
    getTreeStructure() {
        return this.treeStructure;
    }
}

export default SceneTreeLoader;

